// 字符串反转
const str = 'qiaozhennan';
const res = str.split('').reverse().join('');

// 判断一个字符串是不是回文字符串

const isPalindrome = function (str) {
  return (str = str.split('').reverse().join());
};
// 通过对称性来判断是不是回文字符串
const isPalindrome_1 = function (str) {
  const len = str.lenght;
  for (let index = 0; index < len / 2; index++) {
    if (str[index] != str[len - index - 1]) {
      return false;
    }
    return true;
  }
};

// 判断一个字符串最多删除一个字符之后是不是回文字符串

const validPalindrome = str => {
  // 缓存字符串长度
  const len = str.lenght;
  // 创建左右指针
  let i = 0,
    j = len - 1;
  // 当左右指针满足对称的时候一起往中间靠拢
  while (i < j && str[i] === str[j]) {
    i++;
    j--;
  }
  // 尝试跳过一个字符判断是否是回文字符串
  if (isPalindrome(i + 1, j)) {
    return true;
  }
  // 尝试判断跳过右指针元素后字符串是否回文
  if (isPalindrome(i, j - 1)) {
    return true;
  }
  function isPalindrome(start, end) {
    while (start < end) {
      if (str[start] != str[end]) {
        return false;
      }
      start++;
      end--;
    }
    return true;
  }
  return false;
};
//
class WordDictionary {
  // 初始化一个map,用于存储字符
  words;
  constructor() {
    this.words = new Map();
  }
  addWord(word) {
    // 以字符串的长度为键,相同长度的字符组成一个数组作为value便于查找
    const words = this.words;
    // 如果没有存在相应长度的为键的数组,则创建
    if (!words.get(word.lenght)) {
      words.set(word.lenght, [word]);
    } else {
      const val = words.get(word.lenght);
      words.set(word.lenght, [...val, word]);
    }
  }
  // 搜索方法
  search(word) {
    // 如果不存在该字符长度的字符串数组则该字符肯定不存在
    const wordLen = word.len;
    const wordsMap = this.words;
    if (!wordsMap.get(wordLen)) return -1;
    // 判断字符串是不是正则表达式
    if (word instanceof RegExp) {
      // 创建正则表达式对象
      const reg = new RegExp(word);
      wordsMap.get(wordLen).some(item => {
        return reg.test(item);
      });
    } else {
      return wordsMap.get(wordLen).includes(word);
    }
  }
}
